home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 2003 August / MW 8 2003 CD1.iso / Inside Macworld / Product News / gimp-1.2.4.sit / gimp-1.2.4 / plug-ins / imagemap / imap_menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-11-05  |  13.9 KB  |  512 lines
  1. /*
  2.  * This is a plug-in for the GIMP.
  3.  *
  4.  * Generates clickable image maps.
  5.  *
  6.  * Copyright (C) 1998-1999 Maurits Rijk  lpeek.mrijk@consunet.nl
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21.  *
  22.  */
  23.  
  24. #include "config.h"
  25.  
  26. #include <sys/types.h>
  27. #include <sys/stat.h>
  28.  
  29. #include "imap_circle.h"
  30. #include "imap_file.h"
  31. #include "imap_grid.h"
  32. #include "imap_main.h"
  33. #include "imap_menu.h"
  34. #include "imap_menu_funcs.h"
  35. #include "imap_polygon.h"
  36. #include "imap_popup.h"
  37. #include "imap_preferences.h"
  38. #include "imap_rectangle.h"
  39. #include "imap_settings.h"
  40. #include "imap_source.h"
  41. #include "imap_tools.h"
  42.  
  43. #include "libgimp/stdplugins-intl.h"
  44.  
  45. static gint _menu_callback_lock;
  46. static Menu_t _menu;
  47.  
  48. static void
  49. menu_select(GtkWidget *item)
  50. {
  51.    _menu_callback_lock = TRUE;
  52.    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
  53. }
  54.  
  55. static void
  56. menu_mru(GtkWidget *widget, gpointer data)
  57. {
  58.    MRU_t *mru = get_mru();
  59.    char *filename = (char*) data;
  60.    struct stat buf;
  61.    int err;
  62.  
  63.    err = stat(filename, &buf);
  64.    if (!err && (buf.st_mode & S_IFREG)) {
  65.       load(filename);
  66.    } else {
  67.       do_file_error_dialog(_("Error opening file"), filename);
  68.       mru_remove(mru, filename);
  69.       menu_build_mru_items(mru);
  70.    }
  71. }
  72.  
  73. void
  74. menu_set_zoom_sensitivity(gint factor)
  75. {
  76.    gtk_widget_set_sensitive(_menu.zoom_in, factor < 8);
  77.    gtk_widget_set_sensitive(_menu.zoom_out, factor > 1);
  78. }
  79.  
  80. void
  81. menu_shapes_selected(gint count)
  82. {
  83.    gint sensitive = (count > 0);
  84.    gtk_widget_set_sensitive(_menu.cut, sensitive);
  85.    gtk_widget_set_sensitive(_menu.copy, sensitive);
  86.    gtk_widget_set_sensitive(_menu.clear, sensitive);
  87.    gtk_widget_set_sensitive(_menu.edit, sensitive);
  88. }
  89.  
  90. static void
  91. menu_zoom_to(gint factor)
  92. {
  93.    if (_menu_callback_lock) {
  94.       _menu_callback_lock--;
  95.    } else {
  96.       set_zoom(factor);
  97.    }
  98.    menu_set_zoom_sensitivity(factor);
  99. }
  100.  
  101. static void
  102. menu_zoom_to_1(GtkWidget *widget, gpointer data)
  103. {
  104.    menu_zoom_to(1);
  105. }
  106.  
  107. static void
  108. menu_zoom_to_2(GtkWidget *widget, gpointer data)
  109. {
  110.    menu_zoom_to(2);
  111. }
  112.  
  113. static void
  114. menu_zoom_to_3(GtkWidget *widget, gpointer data)
  115. {
  116.    menu_zoom_to(3);
  117. }
  118.  
  119. static void
  120. menu_zoom_to_4(GtkWidget *widget, gpointer data)
  121. {
  122.    menu_zoom_to(4);
  123. }
  124.  
  125. static void
  126. menu_zoom_to_5(GtkWidget *widget, gpointer data)
  127. {
  128.    menu_zoom_to(5);
  129. }
  130.  
  131. static void
  132. menu_zoom_to_6(GtkWidget *widget, gpointer data)
  133. {
  134.    menu_zoom_to(6);
  135. }
  136.  
  137. static void
  138. menu_zoom_to_7(GtkWidget *widget, gpointer data)
  139. {
  140.    menu_zoom_to(7);
  141. }
  142.  
  143. static void
  144. menu_zoom_to_8(GtkWidget *widget, gpointer data)
  145. {
  146.    menu_zoom_to(8);
  147. }
  148.  
  149. static void
  150. menu_rectangle(GtkWidget *widget, gpointer data)
  151. {
  152.    if (_menu_callback_lock) {
  153.       _menu_callback_lock = FALSE;
  154.    } else {
  155.       set_rectangle_func();
  156.       tools_select_rectangle();
  157.       popup_select_rectangle();
  158.    }
  159. }
  160.  
  161. static void
  162. menu_circle(GtkWidget *widget, gpointer data)
  163. {
  164.    if (_menu_callback_lock) {
  165.       _menu_callback_lock = FALSE;
  166.    } else {
  167.       set_circle_func();
  168.       tools_select_circle();
  169.       popup_select_circle();
  170.    }
  171. }
  172.  
  173. static void
  174. menu_polygon(GtkWidget *widget, gpointer data)
  175. {
  176.    if (_menu_callback_lock) {
  177.       _menu_callback_lock = FALSE;
  178.    } else {
  179.       set_polygon_func();
  180.       tools_select_polygon();
  181.       popup_select_polygon();
  182.    }
  183. }
  184.  
  185. static void
  186. menu_arrow(GtkWidget *widget, gpointer data)
  187. {
  188.    if (_menu_callback_lock) {
  189.       _menu_callback_lock = FALSE;
  190.    } else {
  191.       set_arrow_func();
  192.       tools_select_arrow();
  193.       popup_select_arrow();
  194.    }
  195. }
  196.  
  197. static void
  198. menu_grid(GtkWidget *widget, gpointer data)
  199. {
  200.    if (_menu_callback_lock) {
  201.       _menu_callback_lock = FALSE;
  202.    } else {
  203.       gint grid = toggle_grid();
  204.       popup_check_grid(grid);
  205.       main_toolbar_set_grid(grid);
  206.    }
  207. }
  208.  
  209. static void
  210. make_file_menu(GtkWidget *menu_bar)
  211. {
  212.    GtkWidget     *file_menu = make_menu_bar_item(menu_bar, _("File"));
  213.    GtkWidget    *item;
  214.  
  215.    _menu.file_menu = file_menu;
  216.    item = make_item_with_label(file_menu, _("Open..."), menu_command,
  217.                    &_menu.cmd_open);
  218.    add_accelerator(item, 'O', GDK_CONTROL_MASK);
  219.    item = make_item_with_label(file_menu, _("Save"), menu_command,
  220.                    &_menu.cmd_save);
  221.    add_accelerator(item, 'S', GDK_CONTROL_MASK);
  222.    make_item_with_label(file_menu, _("Save As..."), menu_command,
  223.             &_menu.cmd_save_as);
  224.    make_separator(file_menu);
  225.    make_item_with_label(file_menu, _("Preferences..."), menu_command,
  226.             &_menu.cmd_preferences);
  227.    make_separator(file_menu);
  228.    item = make_item_with_label(file_menu, _("Close"), menu_command,
  229.                    &_menu.cmd_close);
  230.    add_accelerator(item, 'W', GDK_CONTROL_MASK);
  231.    item = make_item_with_label(file_menu, _("Quit"), menu_command,
  232.                    &_menu.cmd_quit);
  233.    add_accelerator(item, 'Q', GDK_CONTROL_MASK);
  234. }
  235.  
  236. static void
  237. command_list_changed(Command_t *command, gpointer data)
  238. {
  239.    gchar *scratch;
  240.  
  241.    /* Set undo entry */
  242.    if (_menu.undo)
  243.       gtk_widget_destroy(_menu.undo);
  244.    scratch = g_strdup_printf (_("Undo %s"), 
  245.                               command && command->name ? command->name : "");
  246.    _menu.undo = insert_item_with_label(_menu.edit_menu, 1, scratch,
  247.                        menu_command, &_menu.cmd_undo);
  248.    g_free (scratch);
  249.    add_accelerator(_menu.undo, 'Z', GDK_CONTROL_MASK);
  250.    gtk_widget_set_sensitive(_menu.undo, (command != NULL));
  251.  
  252.    /* Set redo entry */
  253.    command = command_list_get_redo_command();
  254.    if (_menu.redo)
  255.       gtk_widget_destroy(_menu.redo);
  256.    scratch = g_strdup_printf (_("Redo %s"), 
  257.                               command && command->name ? command->name : "");
  258.    _menu.redo = insert_item_with_label(_menu.edit_menu, 2, scratch,
  259.                        menu_command, &_menu.cmd_redo);
  260.    g_free (scratch);
  261.    add_accelerator(_menu.redo, 'R', GDK_CONTROL_MASK);
  262.    gtk_widget_set_sensitive(_menu.redo, (command != NULL));
  263. }
  264.  
  265. static void
  266. paste_buffer_added(Object_t *obj, gpointer data)
  267. {
  268.    gtk_widget_set_sensitive((GtkWidget*) data, TRUE);
  269. }
  270.  
  271. static void
  272. paste_buffer_removed(Object_t *obj, gpointer data)
  273. {
  274.    gtk_widget_set_sensitive((GtkWidget*) data, FALSE);
  275. }
  276.  
  277. static void
  278. make_edit_menu(GtkWidget *menu_bar)
  279. {
  280.    GtkWidget *edit_menu = make_menu_bar_item(menu_bar, _("Edit"));
  281.    GtkWidget *item, *paste;
  282.  
  283.    _menu.edit_menu = edit_menu;
  284.    command_list_changed(NULL, NULL);
  285.  
  286.    make_separator(edit_menu);
  287.    _menu.cut = make_item_with_label(edit_menu, _("Cut"), menu_command,
  288.                     &_menu.cmd_cut);
  289.    add_accelerator(_menu.cut, 'X', GDK_CONTROL_MASK);
  290.    _menu.copy = make_item_with_label(edit_menu, _("Copy"), menu_command,
  291.                      &_menu.cmd_copy);
  292.    add_accelerator(_menu.copy, 'C', GDK_CONTROL_MASK);
  293.    paste = make_item_with_label(edit_menu, _("Paste"), menu_command,
  294.                 &_menu.cmd_paste);
  295.    add_accelerator(paste, 'V', GDK_CONTROL_MASK);
  296.    gtk_widget_set_sensitive(paste, FALSE);
  297.    item = make_item_with_label(edit_menu, _("Select All"), menu_command,
  298.                    &_menu.cmd_select_all);
  299.    add_accelerator(item, 'A', GDK_CONTROL_MASK);
  300.    make_separator(edit_menu);
  301.    _menu.clear = make_item_with_label(edit_menu, _("Clear"), menu_command,
  302.                       &_menu.cmd_clear);
  303.    add_accelerator(_menu.clear, 'K', GDK_CONTROL_MASK);
  304.    _menu.edit = make_item_with_label(edit_menu, _("Edit Area Info..."),
  305.                      menu_command, &_menu.cmd_edit_area_info);
  306.  
  307.    paste_buffer_add_add_cb(paste_buffer_added, (gpointer) paste);
  308.    paste_buffer_add_remove_cb(paste_buffer_removed, (gpointer) paste);
  309.  
  310.    command_list_add_update_cb(command_list_changed, NULL);
  311. }
  312.  
  313. static void
  314. make_view_menu(GtkWidget *menu_bar)
  315. {
  316.    GtkWidget *view_menu = make_menu_bar_item(menu_bar, _("View"));
  317.    GtkWidget *zoom_menu, *item;
  318.    GSList *group = NULL;
  319.  
  320.    item = make_check_item(view_menu, _("Area List"), menu_command,
  321.               &_menu.cmd_area_list);
  322.    GTK_CHECK_MENU_ITEM(item)->active = TRUE;
  323.  
  324.    make_item_with_label(view_menu, _("Source..."), menu_command,
  325.             &_menu.cmd_source);
  326.    make_separator(view_menu);
  327.  
  328.    _menu.color = make_radio_item(view_menu, NULL, _("Color"), menu_command,
  329.                  &_menu.cmd_color);
  330.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.color));
  331.  
  332.    _menu.gray = make_radio_item(view_menu, group, _("Grayscale"), menu_command,
  333.                 &_menu.cmd_gray);
  334.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.gray));
  335.  
  336.    if (!get_map_info()->color) { /* Gray image */
  337.       gtk_widget_set_sensitive(_menu.color, FALSE);
  338.       GTK_CHECK_MENU_ITEM(_menu.color)->active = FALSE;
  339.       GTK_CHECK_MENU_ITEM(_menu.gray)->active = TRUE;
  340.    }
  341.  
  342.    make_separator(view_menu);
  343.  
  344.    _menu.zoom_in = make_item_with_label(view_menu, _("Zoom In"), menu_command,
  345.                     &_menu.cmd_zoom_in);
  346.    add_accelerator(_menu.zoom_in, '=', 0);
  347.    _menu.zoom_out = make_item_with_label(view_menu, _("Zoom Out"), 
  348.                      menu_command, &_menu.cmd_zoom_out);
  349.    add_accelerator(_menu.zoom_out, '-', 0);
  350.    gtk_widget_set_sensitive(_menu.zoom_out, FALSE);
  351.  
  352.    zoom_menu = make_sub_menu(view_menu, _("Zoom To"));
  353.  
  354.    _menu.zoom[0] = make_radio_item(zoom_menu, NULL, "1:1", menu_zoom_to_1,
  355.                    NULL);
  356.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[0]));
  357.    _menu.zoom[1] = make_radio_item(zoom_menu, group, "1:2", menu_zoom_to_2,
  358.                    NULL);
  359.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[1]));
  360.    _menu.zoom[2] = make_radio_item(zoom_menu, group, "1:3", menu_zoom_to_3,
  361.                    NULL);
  362.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[2]));
  363.    _menu.zoom[3] = make_radio_item(zoom_menu, group, "1:4", menu_zoom_to_4,
  364.                    NULL);
  365.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[3]));
  366.    _menu.zoom[4] = make_radio_item(zoom_menu, group, "1:5", menu_zoom_to_5,
  367.                    NULL);
  368.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[4]));
  369.    _menu.zoom[5] = make_radio_item(zoom_menu, group, "1:6", menu_zoom_to_6,
  370.                    NULL);
  371.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[5]));
  372.    _menu.zoom[6] = make_radio_item(zoom_menu, group, "1:7", menu_zoom_to_7,
  373.                    NULL);
  374.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.zoom[6]));
  375.    _menu.zoom[7] = make_radio_item(zoom_menu, group, "1:8", menu_zoom_to_8,
  376.                    NULL);
  377. }
  378.  
  379. static void
  380. make_mapping_menu(GtkWidget *menu_bar)
  381. {
  382.    GtkWidget *menu = make_menu_bar_item(menu_bar, _("Mapping"));
  383.    GSList    *group;
  384.  
  385.    _menu.arrow = make_radio_item(menu, NULL, _("Arrow"), menu_arrow, NULL);
  386.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.arrow));
  387.    _menu.rectangle = make_radio_item(menu, group, _("Rectangle"),
  388.                      menu_rectangle, NULL);
  389.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.rectangle));
  390.    _menu.circle = make_radio_item(menu, group, _("Circle"), menu_circle, NULL);
  391.    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(_menu.circle));
  392.    _menu.polygon = make_radio_item(menu, group, _("Polygon"), menu_polygon,
  393.                    NULL);
  394.    make_separator(menu);
  395.    make_item_with_label(menu, _("Edit Map Info..."), menu_command,
  396.             &_menu.cmd_edit_map_info);
  397. }
  398.  
  399. static void
  400. make_goodies_menu(GtkWidget *menu_bar)
  401. {
  402.    GtkWidget *goodies_menu = make_menu_bar_item(menu_bar, _("Goodies"));
  403.    _menu.grid = make_check_item(goodies_menu, _("Grid"), menu_grid, NULL);
  404.    make_item_with_label(goodies_menu, _("Grid Settings..."), menu_command,
  405.             &_menu.cmd_grid_settings);
  406.    make_item_with_label(goodies_menu, _("Create Guides..."), menu_command,
  407.             &_menu.cmd_create_guides);
  408. }
  409.  
  410. static void
  411. make_help_menu(GtkWidget *menu_bar)
  412. {
  413.    GtkWidget *help_menu = make_menu_bar_item(menu_bar, _("Help"));
  414.    gtk_menu_item_right_justify(GTK_MENU_ITEM(gtk_menu_get_attach_widget(
  415.       GTK_MENU(help_menu))));
  416.    make_item_with_label(help_menu, _("About ImageMap..."), menu_command,
  417.             &_menu.cmd_about);
  418. }
  419.  
  420. Menu_t*
  421. make_menu(GtkWidget *main_vbox, GtkWidget *window)
  422. {
  423.    GtkWidget *menu_bar = gtk_menu_bar_new();
  424.  
  425.    gtk_box_pack_start(GTK_BOX(main_vbox), menu_bar, FALSE, TRUE, 0);
  426.    gtk_widget_show(menu_bar);
  427.  
  428.    init_accel_group(window);
  429.  
  430.    make_file_menu(menu_bar);
  431.    make_edit_menu(menu_bar);
  432.    make_view_menu(menu_bar);
  433.    make_mapping_menu(menu_bar);
  434.    make_goodies_menu(menu_bar);
  435.    make_help_menu(menu_bar);
  436.  
  437.    menu_shapes_selected(0);
  438.  
  439.    return &_menu;
  440. }
  441.  
  442. void
  443. menu_build_mru_items(MRU_t *mru)
  444. {
  445.    GList *p;
  446.    gint position = 7;        /* Position of 'Close' entry */
  447.    int i;
  448.  
  449.    if (_menu.nr_off_mru_items) {
  450.       GList *children = gtk_container_children(GTK_CONTAINER(_menu.file_menu));
  451.       
  452.       p = g_list_nth(children, position);
  453.       for (i = 0; i < _menu.nr_off_mru_items; i++, p = p->next) {
  454.      gtk_widget_destroy((GtkWidget*) p->data);
  455.       }
  456.       g_list_free(children);
  457.    }
  458.  
  459.    i = 0;
  460.    for (p = mru->list; p; p = p->next, i++) {
  461.       GtkWidget *item = insert_item_with_label(_menu.file_menu, position++,
  462.                            (gchar*) p->data,
  463.                            menu_mru, p->data);
  464.       if (i < 9) {
  465.      guchar accelerator_key = '1' + i;
  466.      add_accelerator(item, accelerator_key, GDK_CONTROL_MASK);
  467.       }
  468.    }
  469.    insert_separator(_menu.file_menu, position);
  470.    _menu.nr_off_mru_items = i + 1;
  471. }
  472.  
  473. void
  474. menu_select_arrow(void)
  475. {
  476.    menu_select(_menu.arrow);
  477. }
  478.  
  479. void
  480. menu_select_rectangle(void)
  481. {
  482.    menu_select(_menu.rectangle);
  483. }
  484.  
  485. void
  486. menu_select_circle(void)
  487. {
  488.    menu_select(_menu.circle);
  489. }
  490.  
  491. void
  492. menu_select_polygon(void)
  493. {
  494.    menu_select(_menu.polygon);
  495. }
  496.  
  497. void
  498. menu_check_grid(gint check)
  499. {
  500.    _menu_callback_lock = TRUE;
  501.    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(_menu.grid), check);
  502. }
  503.  
  504. void
  505. menu_set_zoom(gint factor)
  506. {
  507.    _menu_callback_lock = 2;
  508.    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(_menu.zoom[factor - 1]),
  509.                   TRUE);
  510.    menu_set_zoom_sensitivity(factor);
  511. }
  512.